var dhnewobject = Object()                                      //     +Object {}    #only1  __proto__: Object(根)
var dhnewObjecstproto = dhnewobject.__proto__                   //     +Object {}    #....一拖拉 2红(根)
var dhnewObjectsprotosproto = dhnewobject.__proto__.__proto__    //    null
//dhnewobject没有prototype, 没有constructor。


var dhobject = Object;                                          //    function Object() { [native code] }
var dhObjecstproto = dhobject.__proto__                         //    function () {}    匿名空函数<root>。
var dhObjectsprotosproto = dhobject.__proto__.__proto__         //    +Object {}    # ....一拖拉 2红(根)
//dhobject.prototype    // +Object {}    # ....一拖拉 2红
//dhObjecstproto没有prototype。也就是 function () {}匿名空函数,没有prototype   
//constructor 是 function Function() { [native code] }


var dhfunction = function(){                                     //    function (){ ...} #  1个匿名函数
  console.log(dhobject, dhnewobject ) ; return 'dddh'; } 
var dhfunctionsproto = dhfunction.__proto__                       //   function () {}  # 匿名空函数<root>。 
var dhfunctionsprotosproto = dhfunction.__proto__.__proto__       //   +Object {}    # ....一拖拉 2红(根)
//dhfunction.prototype  //   +Object {}    #2 constructor: ()  __proto__: Object(根)
//dhfunctionsproto没有prototype。


function dhdeffunction () {                                        //  function dhdeffunction() { ..}  #定义函数
  console.log(dhObjecstproto,dhObjectsprotosproto,
  dhfunctionsproto,dhfunctionsprotosproto,dhdeffunctionsproto,
  dhdeffunctionsprotosproto);
  return 'def dddh22'; 
}
var dhdeffunctionsproto = dhdeffunction.__proto__                   //  function () {} # 匿名函数原型。   
var dhdeffunctionsprotosproto = dhdeffunction.__proto__.__proto__   // +Object {}    # ....一拖拉 2红(根)
//dhdeffunction.prototype   //   +Object {}    #2   constructor:dhdeffunction() __proto__: Object(根)


//function Function() { [native code] } 
//Function.__proto__                       // function () {}匿名函数原型。
//Function.prototype    // function () {}  # 匿名函数原型。 same as  above

a = {"a": 1, "b": ()=>{return 1;}}     // +Object #3 a: 1 b: () __proto__: Object                              
/*
a.__proto__                              // +Object {}    # ....一拖拉 2红(根)
a.a.__proto__                            // Number {[[PrimitiveValue]]: 0}
a.a.__proto__.__proto__                  // +Object {}    # ....一拖拉 2红(根)
a.b.__proto__                            // function () {}  # 匿名函数原型。

a 没有prototype。其中属性也都没有。


x = new Object(); 和 x = Object(); 结果一样。但对于其他函数来说不一样了。这个应该是因为Object本身返回的就是Object。new Object恰巧也是Object而已。




*/


/* 
http://es6.ruanyifeng.com/#docs/reflect

Object.setPrototypeOf()（写操作）、Object.getPrototypeOf()（读操作）、Object.create()（生成操作）代替。

总结：

一切是怎么开始的。
首先要有个能创建一切的东西：于是就有了 Function 对象。用built-in函数写的。分配内存一类的。
因为一切皆是对象。所以，就要在函数中，能生成一个祖宗。Object。派生一切。
function Function() { [native code] }

因为这个祖宗Object<root>很常用，所以，Fucntion派生了一个专门的函数， Object<func> ，用来专门生成他。
function Object() { [native code] }

因为这个规则，所以Function也要是Object<root>的子孙（孙子）。因为Function是一个定义的函数，
js还支持匿名函数。于是，Function 就有了一个父亲。 空函数 function () {} 。空函数继承自Object<root>


 
                                   --- Object
                  ---function(){}  --- Function
null-- Object<root>
                  ---new Object()


o1 = new Object
o2 = Object()
o1.__proto__ === o2.__proto__                   



//*** 一切皆是从对象继承而来的。__proto__属性指明了父亲。比如： 
var Obj = {} 
var rootObj = Obj.__proto__      // +Object{}  根对象。
rootObj.__proto__ === null       // null说明这个rootObj没有上级了，就是根。

//*** rootObj需要一个逻辑来生成。就出现了底层函数Function{<native code>}。
//注意的是，Function的父亲是一个空函数对象：function () {} ，可以生成匿名函数，和定义函数。 //空函数是所有函数的祖宗。function<root>。但是空函数，也是Function生成的。鸡生蛋，蛋生鸡开始。
//所有对象都是有一个函数生成的，所以对象会有一个constructor的属性，指向生成他的函数，也叫构造函数。
//构造函数干活，一般要有一个原型，作为底板。然后用自身的逻辑，来改造生成创意对象。

//因为一切都是对象，这个原型，也是对象，也有一个__proto__指向的继承链的关系，但这个指定的prototype，是半毛钱关系都没有啊。一般来说，没有特殊指向，prototype默认的就是Object()。

//通过new来调用构造函数，然后构造函数就new一个新的prototype，改造一番后，就生成了一个新对象实例返回。



var rootFunc = Function.__proto__
rootFunc.__proto__ === rootObj      // 祖先函数的父亲，是对象。
rootFunc.prototype === undefined    // 唯一一个没有原型的函数。
rootFunc.constructor === Function   // 儿子也能生成老子啊。

Function.prototype === rootFunc
Function.constructor === Function    // true. 创世纪之源泉，自己生成自己啊。

rootObj.constructor === Object    // true, 创建根的函数，是由Function创建的。
Object.constructor === Function   

//*** 

所有对象，__proto__是Object，他的constructor 都是 function Object() { [native code] }
__proto__是function，他的constructor 都是 function Function() { [native code] }

不是复合的Object的原型链不会出现function。复合的对象，会有分叉。像a={"a":1,"b":(c)=>{x=c;}} 
function的原型链一直是function，最后是Object<root>

prototype 是个啥东西呢？ 就是构造函数，生成的一个基类祖先对象的概念。同一个构造函数，对应一个祖先对象。
所有实例对象需要共享的属性和方法，都放在这个对象里面；那些不需要共享的属性和方法，就放在构造函数里面。

除非是简单的储值对象，一般对象是需要用函数根据一定逻辑规则来生成的。所以呢。需要一个构建函数（注意函数也是对象），
叫做constructor。[构造器的__proto__都指向Function.prototype，它是一个空函数（Empty function）]

Javascript规定，每一个构造函数都有一个prototype属性，指向一个对象。这个对象的所有属性和方法，都会被构造函数生成的实例继承。
也就是说，一个构造函数，会产生一个唯一的prototype对象，这个对象，就是他new出来的所有对象的父类。
prototype只有函数(准确地说是构造函数)才有的。它跟原型链没有半毛钱关系。

创建一个对象时，先定义一个构造函数。他要产生一个原型prototype，这个prototype需要能够说明，拷贝自那个对象，
再执行什么逻辑规则改造成一个需求的原型。比如：
function Fn(){this.x=1} 
这样，定义了一个Fn构造函数，他的prototype有个2个属性：
1个是用来说明，他要拷贝的对象是谁：用__proto__指向，默认就是Object<root>
第2个就处理逻辑，也就是Fn()这个函数，其实就是他自己，用constructor来指向，就是Fn()
Fn.prototype.constructor  === Fn  // ture

创建时候用new方法，var x1 = new Fn。搞定

根据Fn的__proto__指向，生成了一个空Object{}，然后，执行Fn, 增加了一个x:1的属性。
定义生成了一个对象x1, 
这个x1的constructor就是Fn,
他的__proto__原型，就是Fn的prototype中，__proto__指向的对象。也就是Object{}


为什么会理解的乱呢？主要因为，Fn他是构造函数，同时他也是一个函数，函数也是一个对象，它也有自己的construtor. __proto__,
确实容易混淆。




function执行返回什么就是什么，没啥好说的
如果对函数进行new运算的话，就会生成新的对象。并对this操作进行属性赋值。
new 的运算优先级要小于 . 的运算优先级，但是大于()的优先级，所以new后面的函数，加()的时候，就会先执行new 
单纯new函数有没有括号无所谓。但是 new Fn().age  new Fn.age，就不一样了。前者先new Fn, 后者，new的是Fn.age

new做如下事情：
1,创建一个object<root>；
2,设置这个新的对象的内部、可访问性和[[prototype]]属性为构造函数（指prototype.construtor所指向的构造函数）中设置的；
3,执行构造函数，当this关键字被提及的时候，使用新创建的对象的属性；
4,返回新创建的对象（除非构造方法中返回的是‘无原型’）。


new做法是新建一个obj对象o1，并且让o1的__proto__指向了Base.prototype对象。并且使用call 进行强转作用环境。从而实现了实例的创建。


function base(a){ this.a = a}

模拟var x=new base的过程，就是先
1、
var x = new Object();        // 创建对象。
查看x属性，发现：
x.constructor === function Object() { [native code] }
x.__proto__ === Object {}
2、
更改：x.__proto__=base.prototype // 原型链改成构造函数的原型。  --- 这个是关键的主导。
__proto__设置同时x.constructor变成了function base(a){this.a=a}
（若先更改constructor为base，却不能更改__proto__）
3、
base.call(x,1)   // x===Object {a: 1} //用这个对象调用构造函数。

直接new一个看看。
var x1=new base(1)
x1 === base {a: 1}
x  === Object {a: 1}
注意类型并不一样，但是construtor和__proto__是一致的诶

注意：更改x.__proto__=base.prototype时，会自动把constructor变成base函数。

-----------------------------------
function base(a){ this.a = a}
下面模拟一下：Object.create(o)
1、
function F() {};  创建一个空的函数
注意：F.__proto__ === function Empty() {}
  F.prototype === F {}  (应该是个F的Object)
  F.constructor ===function Function() { [native code] }

2、
F.prototype = base;     
F.__proto__、construtor都没有变更。

3、
new F(1);
F {b: 1}

Object {}



var Base = function () {
    this.a = 2
}
var o1 = new Base();
var o2 = Object.create(Base);
console.log(o1.a);
console.log(o2.a);



function Foo(){
}
Foo.prototype = {}
var a1 = new Foo();
console.log(a1.constructor === Foo);//false
console.log(a1.constructor === Object);//true


可以看到a1并没有.constructor属性。那是为什么呢。？因为a1没有.constructor属性，他会委托[[prototype]]链上的Foo.prototype。但是新建的Foo.prototype也没有.constructor,所以继续往上找，一直到了顶端的Object.prototype。 





*/
